#ifndef TERRAIN_H
#define TERRAIN_H

#include "parcelle.hpp"
#include "lecteur.hpp"
#include <cstdlib>
#include <vector>

using namespace std;

struct bassin_t
{
    unsigned int id;
    Parcelle puit;
};

struct parchaine
{
    Parcelle * parc;
    parchaine * maillon;
};


class Terrain
{
private :
    unsigned int nbBassin;//nombre de bassin déja attribué"
    vector<bassin_t>* lesBassins;
    Parcelle* lesParcelles_up;
    Parcelle* lesParcelles_center;
    Parcelle* lesParcelles_down;
    Parcelle* lesParcelles_downdown;
    int* ligneCourante;
    int* ecriture;
    unsigned int lignes_traitees;
    FileManager * lecteur;

    map<int,int> MAJBassin;

public:
    Terrain()
    {
        this->nbBassin = 0;
        this->lesBassins = new vector<bassin_t>();

        //this-> ligneCourante = new vector<unsigned int>();
        this->lecteur = NULL;
        this->lignes_traitees = 0;
    }

    ~Terrain()
    {
        if (lesBassins)
        {
            lesBassins->clear();
            delete lesBassins;
        }
        if(lesParcelles_up)
        {
            delete lesParcelles_up;
        }
        if (lesParcelles_center)
        {
            delete lesParcelles_center;
        }
        if (lesParcelles_down)
        {
            delete lesParcelles_down;
        }
        if (ligneCourante)
        {
            //ligneCourante->clear();
            delete ligneCourante;
        }

    }

    unsigned int getNbBassin()
    {
        return nbBassin;
    };
    vector<bassin_t>* getLesBassins()
    {
        return lesBassins;
    }
    Parcelle* getP_UP()
    {
        return lesParcelles_up;
    }
    Parcelle* getP_CENTER()
    {
        return lesParcelles_center;
    }
    Parcelle* getP_DOWN()
    {
        return lesParcelles_down;
    }
    Parcelle* getParcelle(unsigned int x, unsigned int y)
    {
        ////////////////////////////

        if(lesParcelles_up != NULL && lesParcelles_up[x].getOrd() == y)
        {
            return &lesParcelles_up[x];
        }
        if(lesParcelles_center != NULL && lesParcelles_center[x].getOrd() == y)
        {
            return &lesParcelles_center[x];
        }
        if(lesParcelles_down != NULL && lesParcelles_down[x].getOrd() == y)
        {
            return &lesParcelles_down[x];
        }
        if(lesParcelles_downdown != NULL && lesParcelles_downdown[x].getOrd() == y)
        {
            return &lesParcelles_downdown[x];
        }
        return NULL;
    }



    FileManager* getLecteur()
    {
        return lecteur;
    }
    void setLecteur(FileManager* f)
    {
        lecteur= f;
    }

    void calcul();

    void setNbBassin(unsigned int i)
    {
        nbBassin = i;
    }
    Parcelle* calculCible(Parcelle *p);
    void calculCuvette(Parcelle *p);


    void afficheLesBassins();
    void calculRegroupBassin();

    void filtreCalculCuvette(Parcelle & p);
};





#endif
